package com.hifar.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.aspose.cells.Workbook;
import com.aspose.cells.Worksheet;
import com.hifar.fw.utils.lang.StringUtils;
import com.hifar.plat.AopOption.Excel;
import com.hifar.plat.officUtil.AsposeUtils;
import com.hifar.plat.maindatasource.service.IMainDataSourceService;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Excel数据导入工具类
 * 支持多种日期格式的智能解析
 *
 * @author : maiti
 * @date : 2025/3/18 9:33
 */
public class ExcelImportUtils {

    /**
     * 导入Excel数据，支持多种日期格式和字典项翻译
     * 
     * @param inputStream Excel文件输入流
     * @param clazz 目标实体类
     * @param mainDataSourceService 数据源服务，用于字典项翻译
     * @return 解析后的实体对象列表
     * @throws Exception 解析异常
     */
    public static <T> List<T> importExcel(InputStream inputStream, Class<T> clazz, IMainDataSourceService mainDataSourceService) throws Exception {
        try {
            AsposeUtils.loadLicense("1");
        } catch (Exception e) {
            e.printStackTrace();
        }

        Workbook workbook = new Workbook(inputStream);
        Worksheet worksheet = workbook.getWorksheets().get(0);
        int maxDataRow = worksheet.getCells().getMaxDataRow();
        int maxDataColumn = worksheet.getCells().getMaxDataColumn();
        
        System.out.println("Excel解析调试信息:");
        System.out.println("最大数据行数: " + maxDataRow);
        System.out.println("最大数据列数: " + maxDataColumn);
        
        Map<Integer, String> map = new HashMap<>();
        Map<Integer, String> dictCodeMap = new HashMap<>();
        Field[] fields = clazz.getDeclaredFields();
        int i = fields.length;
        

        // 获取字典项映射 - 使用两步查询法
        Map<String, String> dictMapping = null;
        if (mainDataSourceService != null) {
            // 动态获取所有需要的字典代码
            Set<String> dictCodes = new HashSet<>();
            for (Field field : fields) {
                if (field.getAnnotation(Excel.class) != null) {
                    String dictCode = field.getAnnotation(Excel.class).dictCode();
                    if (StringUtils.isNotBlank(dictCode)) {
                        dictCodes.add(dictCode);
                    }
                }
            }
            
            if (!dictCodes.isEmpty()) {
                String dictCodeList = dictCodes.stream()
                        .map(code -> "'" + code + "'")
                        .collect(Collectors.joining(","));
                
                try {
                    // 第一步：查询字典分类表获取ID
                    String classifySql = "select id, dict_code from base_sys_dict_classify where " +
                            "dict_code in(" + dictCodeList + ") and status<>99 and del_flag=0";
                    List<Map<String, Object>> classifyList = mainDataSourceService.selectList(classifySql);
                    
                    if (!classifyList.isEmpty()) {
                        // 构建分类ID列表
                        String classifyIds = classifyList.stream()
                                .map(item -> StringUtils.trimNull(item.get("id")))
                                .collect(Collectors.joining(","));
                        
                        // 第二步：根据分类ID查询字典项
                        String itemSql = "select c.dict_code, i.item_key, i.item_value from base_sys_dict_item i " +
                                "inner join base_sys_dict_classify c on i.dict_id = c.id " +
                                "where i.dict_id in(" + classifyIds + ") and i.status<>99 and i.del_flag=0";
                        List<Map<String, Object>> dictLit = mainDataSourceService.selectList(itemSql);
                        
                        dictMapping = dictLit.stream()
                                .collect(Collectors.toMap(
                                        item -> StringUtils.trimNull(item.get("dictCode")) + "#"
                                                + StringUtils.trimNull(item.get("itemKey")),
                                        item -> StringUtils.trimNull(item.get("itemValue")), (o1, o2) -> o1));
                    }
                } catch (Exception e) {
                    System.out.println("工具类-获取字典项失败: " + e.getMessage());
                    e.printStackTrace();
                }
            }
        }

        for (int k = 0; k < i; ++k) {
            Field field = fields[k];
            if (field.getAnnotation(Excel.class) != null) {
                String name = ((Excel) field.getAnnotation(Excel.class)).name();
                String objName = field.getName();
                String dictCode = ((Excel) field.getAnnotation(Excel.class)).dictCode();
                
                System.out.println("处理字段: " + objName + ", Excel名称: " + name + ", dictCode: " + dictCode);

                for (int j = 0; j <= maxDataColumn; ++j) {
                    Object headerValue = worksheet.getCells().get(1, j).getValue();
                    if (name.equals(headerValue)) {
                        map.put(j, objName);
                        if (StringUtils.isNotBlank(dictCode)) {
                            dictCodeMap.put(j, dictCode);
                        }
                        System.out.println("匹配成功: 列" + j + " -> " + objName + " (header: " + headerValue + ")");
                    }
                }
            }
        }
        
        System.out.println("字段映射结果: " + map);
        System.out.println("字典代码映射: " + dictCodeMap);

        JSONArray jsonArray = new JSONArray();

        for (i = 0; i <= maxDataRow; ++i) {
            JSONObject jsonObject = new JSONObject();
            
            if (i == 0) {
                System.out.println("第0行(标题行): ");
                for (int j = 0; j <= maxDataColumn; ++j) {
                    Object titleValue = worksheet.getCells().get(i, j).getValue();
                    System.out.println("  列" + j + ": " + titleValue);
                }
            } else if (i == 1) {
                System.out.println("第1行(表头行): ");
                for (int j = 0; j <= maxDataColumn; ++j) {
                    Object headerValue = worksheet.getCells().get(i, j).getValue();
                    System.out.println("  列" + j + ": " + headerValue);
                }
            }

            for (int j = 0; j <= maxDataColumn; ++j) {
                if (i >= 2) {
                    Object cellValue = worksheet.getCells().get(i, j).getValue();
                    String value = StringUtils.trimNull(cellValue);
                    
                    if (i == 2) { // 只打印第一行数据的调试信息
                        System.out.println("第" + i + "行数据: 列" + j + " = " + cellValue + " (处理后: " + value + ")");
                    }
                    
                    // 增强：支持日期格式解析和字典项翻译
                    Object processedValue = enhanceCellValueWithDict(value, map.get(j), fields, dictCodeMap.get(j), dictMapping);
                    jsonObject.put((String) map.get(j), processedValue);
                }
            }

            if (!jsonObject.isEmpty()) {
                if (i == 2) { // 只打印第一行数据的JSON
                    System.out.println("第" + i + "行JSON: " + jsonObject.toJSONString());
                }
                jsonArray.add(jsonObject);
            }
        }
        
        System.out.println("解析完成，总数据行数: " + jsonArray.size());

        List<T> list = JSONArray.parseArray(jsonArray.toJSONString(), clazz);
        return list;
    }

    /**
     * 导入Excel数据，支持多种日期格式
     * 
     * @param inputStream Excel文件输入流
     * @param clazz 目标实体类
     * @return 解析后的实体对象列表
     * @throws Exception 解析异常
     */
    public static <T> List<T> importExcel(InputStream inputStream, Class<T> clazz) throws Exception {
        try {
            AsposeUtils.loadLicense("1");
        } catch (Exception e) {
            e.printStackTrace();
        }

        Workbook workbook = new Workbook(inputStream);
        Worksheet worksheet = workbook.getWorksheets().get(0);
        int maxDataRow = worksheet.getCells().getMaxDataRow();
        int maxDataColumn = worksheet.getCells().getMaxDataColumn();
        
        System.out.println("Excel解析调试信息(无字典翻译版本):");
        System.out.println("最大数据行数: " + maxDataRow);
        System.out.println("最大数据列数: " + maxDataColumn);
        
        Map<Integer, String> map = new HashMap<>();
        Field[] fields = clazz.getDeclaredFields();
        int i = fields.length;
        

        for (int k = 0; k < i; ++k) {
            Field field = fields[k];
            if (field.getAnnotation(Excel.class) != null) {
                String name = ((Excel) field.getAnnotation(Excel.class)).name();
                String objName = field.getName();
                
                System.out.println("处理字段: " + objName + ", Excel名称: " + name);

                for (int j = 0; j <= maxDataColumn; ++j) {
                    Object headerValue = worksheet.getCells().get(1, j).getValue();
                    if (name.equals(headerValue)) {
                        map.put(j, objName);
                        System.out.println("匹配成功: 列" + j + " -> " + objName + " (header: " + headerValue + ")");
                    }
                }
            }
        }
        
        System.out.println("字段映射结果: " + map);

        JSONArray jsonArray = new JSONArray();

        for (i = 0; i <= maxDataRow; ++i) {
            JSONObject jsonObject = new JSONObject();
            
            if (i == 0) {
                System.out.println("第0行(标题行): ");
                for (int j = 0; j <= maxDataColumn; ++j) {
                    Object titleValue = worksheet.getCells().get(i, j).getValue();
                    System.out.println("  列" + j + ": " + titleValue);
                }
            } else if (i == 1) {
                System.out.println("第1行(表头行): ");
                for (int j = 0; j <= maxDataColumn; ++j) {
                    Object headerValue = worksheet.getCells().get(i, j).getValue();
                    System.out.println("  列" + j + ": " + headerValue);
                }
            }

            for (int j = 0; j <= maxDataColumn; ++j) {
                if (i >= 2) {
                    Object cellValue = worksheet.getCells().get(i, j).getValue();
                    String value = StringUtils.trimNull(cellValue);
                    
                    if (i == 2) { // 只打印第一行数据的调试信息
                        System.out.println("第" + i + "行数据: 列" + j + " = " + cellValue + " (处理后: " + value + ")");
                    }
                    
                    // 增强：支持日期格式解析
                    Object processedValue = enhanceCellValue(value, map.get(j), fields);
                    jsonObject.put((String) map.get(j), processedValue);
                }
            }

            if (!jsonObject.isEmpty()) {
                if (i == 2) { // 只打印第一行数据的JSON
                    System.out.println("第" + i + "行JSON: " + jsonObject.toJSONString());
                }
                jsonArray.add(jsonObject);
            }
        }
        
        System.out.println("解析完成，总数据行数: " + jsonArray.size());

        List<T> list = JSONArray.parseArray(jsonArray.toJSONString(), clazz);
        return list;
    }

    /**
     * 增强单元格值处理，支持日期格式解析和字典项翻译
     * 
     * @param value 原始值
     * @param fieldName 字段名
     * @param fields 所有字段数组
     * @param dictCode 字典代码
     * @param dictMapping 字典映射
     * @return 处理后的值
     */
    private static Object enhanceCellValueWithDict(String value, String fieldName, Field[] fields, String dictCode, Map<String, String> dictMapping) {
        if (value == null || value.trim().isEmpty()) {
            return removeSuffix(value);
        }
        
        // 保持原有的 removeSuffix 逻辑
        value = removeSuffix(value);
        
        // 字典项翻译
        if (StringUtils.isNotBlank(dictCode) && dictMapping != null && StringUtils.isNotBlank(value)) {
            String dictKey = dictCode + "#" + value;
            String dictValue = dictMapping.get(dictKey);
            if (dictValue != null) {
                System.out.println("字典翻译成功: " + fieldName + " [" + value + "] -> [" + dictValue + "] (dictCode: " + dictCode + ")");
                value = dictValue;
            } else {
                System.out.println("字典项未找到: " + fieldName + " [" + value + "] (dictCode: " + dictCode + ", dictKey: " + dictKey + ")");
                // 尝试反向查找，看是否有值到键的映射
                for (Map.Entry<String, String> entry : dictMapping.entrySet()) {
                    if (entry.getKey().startsWith(dictCode + "#") && entry.getValue().equals(value)) {
                        String foundKey = entry.getKey().substring(entry.getKey().indexOf("#") + 1);
                        System.out.println("发现反向映射: " + fieldName + " [" + value + "] 对应键 [" + foundKey + "]");
                        break;
                    }
                }
            }
        }
        
        // 增强：查找对应字段并检查是否为日期类型
        Field targetField = findFieldByName(fieldName, fields);
        if (targetField != null && isDateField(targetField)) {
            Excel excelAnnotation = targetField.getAnnotation(Excel.class);
            if (excelAnnotation != null) {
                return parseDateValue(value, excelAnnotation);
            }
        }
        
        return value;
    }

    /**
     * 增强单元格值处理，支持日期格式解析
     * 保持原有逻辑不变，只做增强
     * 
     * @param value 原始值
     * @param fieldName 字段名
     * @param fields 所有字段数组
     * @return 处理后的值
     */
    private static Object enhanceCellValue(String value, String fieldName, Field[] fields) {
        if (value == null || value.trim().isEmpty()) {
            return removeSuffix(value); // 保持原有逻辑
        }
        
        // 保持原有的 removeSuffix 逻辑
        value = removeSuffix(value);
        
        // 增强：查找对应字段并检查是否为日期类型
        Field targetField = findFieldByName(fieldName, fields);
        if (targetField != null && isDateField(targetField)) {
            Excel excelAnnotation = targetField.getAnnotation(Excel.class);
            if (excelAnnotation != null) {
                return parseDateValue(value, excelAnnotation);
            }
        }
        
        // 保持原有逻辑：直接返回处理后的值
        return value;
    }
    
    /**
     * 根据字段名查找字段
     * 
     * @param fieldName 字段名
     * @param fields 字段数组
     * @return 找到的字段
     */
    private static Field findFieldByName(String fieldName, Field[] fields) {
        if (fieldName == null || fields == null) {
            return null;
        }
        
        for (Field field : fields) {
            if (fieldName.equals(field.getName())) {
                return field;
            }
        }
        return null;
    }
    
    /**
     * 解析日期值（增强功能）
     * 
     * @param value 日期字符串
     * @param excelAnnotation Excel注解
     * @return 解析后的日期对象或原始字符串
     */
    private static Object parseDateValue(String value, Excel excelAnnotation) {
        try {
            // 如果启用了智能日期解析
            if (excelAnnotation.smartDateParse()) {
                try {
                    // 简单的日期解析，可以根据需要扩展
                    java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd");
                    Date date = sdf.parse(value);
                    if (date != null) {
                        return date;
                    }
                } catch (Exception e) {
                    System.out.println("日期解析失败: " + value + ", 错误: " + e.getMessage());
                }
            }
            
            // 如果指定了格式
            if (!excelAnnotation.format().isEmpty()) {
                try {
                    java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(excelAnnotation.format());
                    Date date = sdf.parse(value);
                    if (date != null) {
                        return date;
                    }
                } catch (Exception e) {
                    System.out.println("日期解析失败: " + value + ", 格式: " + excelAnnotation.format() + ", 错误: " + e.getMessage());
                }
            }
            
        } catch (Exception e) {
            // 解析失败，返回原始字符串（保持原有行为）
            System.err.println("日期解析失败: " + value + ", 错误: " + e.getMessage());
        }
        
        return value;
    }
    
    /**
     * 检查字段是否为日期类型
     * 
     * @param field 字段
     * @return 是否为日期类型
     */
    private static boolean isDateField(Field field) {
        if (field == null) {
            return false;
        }
        Class<?> fieldType = field.getType();
        return Date.class.isAssignableFrom(fieldType) || 
               java.sql.Date.class.isAssignableFrom(fieldType) ||
               java.sql.Timestamp.class.isAssignableFrom(fieldType);
    }

    public static String removeSuffix(String input) {
        // 检查字符串是否以 ".0" 结尾
        if (input != null && input.endsWith(".0")) {
            // 去掉 ".0" 后缀
            return input.substring(0, input.length() - 2);
        }
        // 如果没有 ".0" 后缀，直接返回原字符串
        return input;
    }

    /**
     * 测试字典项翻译功能
     * 
     * @param dictMapping 字典映射
     * @param dictCode 字典代码
     * @param value 原始值
     * @return 翻译后的值
     */
    public static String testDictTranslation(Map<String, String> dictMapping, String dictCode, String value) {
        if (StringUtils.isNotBlank(dictCode) && dictMapping != null && StringUtils.isNotBlank(value)) {
            String dictKey = dictCode + "#" + value;
            String dictValue = dictMapping.get(dictKey);
            if (dictValue != null) {
                System.out.println("测试字典翻译: [" + value + "] -> [" + dictValue + "] (dictCode: " + dictCode + ")");
                return dictValue;
            } else {
                System.out.println("测试字典项未找到: [" + value + "] (dictCode: " + dictCode + ", dictKey: " + dictKey + ")");
                return value;
            }
        }
        return value;
    }

    /**
     * 按列顺序导入Excel数据（不依赖表头匹配）
     * 
     * @param inputStream Excel文件输入流
     * @param clazz 目标实体类
     * @return 解析后的实体对象列表
     * @throws Exception 解析异常
     */
    public static <T> List<T> importExcelByColumnOrder(InputStream inputStream, Class<T> clazz) throws Exception {
        try {
            AsposeUtils.loadLicense("1");
        } catch (Exception e) {
            e.printStackTrace();
        }

        Workbook workbook = new Workbook(inputStream);
        Worksheet worksheet = workbook.getWorksheets().get(0);
        int maxDataRow = worksheet.getCells().getMaxDataRow();
        int maxDataColumn = worksheet.getCells().getMaxDataColumn();
        
        System.out.println("按列顺序导入调试信息:");
        System.out.println("最大数据行数: " + maxDataRow);
        System.out.println("最大数据列数: " + maxDataColumn);
        
        // 获取所有带@Excel注解的字段，按sort排序
        Field[] fields = clazz.getDeclaredFields();
        List<Field> excelFields = new ArrayList<>();
        for (Field field : fields) {
            if (field.getAnnotation(Excel.class) != null) {
                excelFields.add(field);
            }
        }
        
        // 按sort排序
        excelFields.sort((f1, f2) -> {
            int sort1 = f1.getAnnotation(Excel.class).sort();
            int sort2 = f2.getAnnotation(Excel.class).sort();
            return Integer.compare(sort1, sort2);
        });
        
        System.out.println("Excel字段数量: " + excelFields.size());
        for (int i = 0; i < excelFields.size(); i++) {
            Field field = excelFields.get(i);
            Excel excel = field.getAnnotation(Excel.class);
            System.out.println("列" + i + ": " + field.getName() + " (Excel名称: " + excel.name() + ", sort: " + excel.sort() + ")");
        }

        JSONArray jsonArray = new JSONArray();

        // 智能判断数据开始行：如果只有1行数据，从第1行开始；否则从第2行开始
        int dataStartRow = (maxDataRow == 1) ? 1 : 2;
        
        // 从数据开始行读取数据
        for (int i = dataStartRow; i <= maxDataRow; i++) {
            JSONObject jsonObject = new JSONObject();
            
            
            for (int j = 0; j < excelFields.size() && j <= maxDataColumn; j++) {
                Object cellValue = worksheet.getCells().get(i, j).getValue();
                String value = StringUtils.trimNull(cellValue);
                
                // 处理数字格式问题（如1.0 -> 1）
                value = formatNumericValue(value, cellValue);
                
                
                // 自动类型转换
                Field field = excelFields.get(j);
                Object convertedValue = convertValueByFieldType(value, field);
                
                
                jsonObject.put(field.getName(), convertedValue);
            }

            if (!jsonObject.isEmpty()) {
                jsonArray.add(jsonObject);
            }
        }
        

        List<T> list = JSONArray.parseArray(jsonArray.toJSONString(), clazz);
        return list;
    }

    /**
     * 根据字段类型自动转换值
     * 
     * @param value 原始字符串值
     * @param field 目标字段
     * @return 转换后的值
     */
    private static Object convertValueByFieldType(String value, Field field) {
        if (value == null || value.trim().isEmpty()) {
            return getDefaultValue(field.getType());
        }
        
        // 检查是否有值映射配置
        Excel excelAnnotation = field.getAnnotation(Excel.class);
        if (excelAnnotation != null && StringUtils.isNotBlank(excelAnnotation.valueMapping())) {
            String mappedValue = applyValueMapping(value, excelAnnotation.valueMapping());
            if (mappedValue != null && !mappedValue.equals(value)) {
                System.out.println("值映射转换: " + field.getName() + " [" + value + "] -> [" + mappedValue + "]");
                value = mappedValue;
            }
        }
        
        Class<?> fieldType = field.getType();
        
        try {
            // 字符串类型
            if (String.class.equals(fieldType)) {
                return value;
            }
            
            // 整数类型
            if (Integer.class.equals(fieldType) || int.class.equals(fieldType)) {
                return Integer.valueOf(value);
            }
            
            // 长整数类型
            if (Long.class.equals(fieldType) || long.class.equals(fieldType)) {
                return Long.valueOf(value);
            }
            
            // 浮点数类型
            if (Double.class.equals(fieldType) || double.class.equals(fieldType)) {
                return Double.valueOf(value);
            }
            
            // 单精度浮点数类型
            if (Float.class.equals(fieldType) || float.class.equals(fieldType)) {
                return Float.valueOf(value);
            }
            
            // 布尔类型
            if (Boolean.class.equals(fieldType) || boolean.class.equals(fieldType)) {
                return Boolean.valueOf(value);
            }
            
            // 日期类型
            if (Date.class.isAssignableFrom(fieldType) || 
                java.sql.Date.class.isAssignableFrom(fieldType) ||
                java.sql.Timestamp.class.isAssignableFrom(fieldType)) {
                return parseDateValue(value, field);
            }
            
            // 其他类型，尝试直接转换
            return value;
            
        } catch (Exception e) {
            System.out.println("类型转换失败: " + field.getName() + " [" + value + "] -> " + fieldType.getSimpleName() + ", 错误: " + e.getMessage());
            return getDefaultValue(fieldType);
        }
    }
    
    /**
     * 获取字段类型的默认值
     * 
     * @param fieldType 字段类型
     * @return 默认值
     */
    private static Object getDefaultValue(Class<?> fieldType) {
        if (fieldType.isPrimitive()) {
            if (int.class.equals(fieldType)) return 0;
            if (long.class.equals(fieldType)) return 0L;
            if (double.class.equals(fieldType)) return 0.0;
            if (float.class.equals(fieldType)) return 0.0f;
            if (boolean.class.equals(fieldType)) return false;
        }
        return null;
    }
    
    /**
     * 解析日期值
     * 
     * @param value 日期字符串
     * @param field 字段
     * @return 解析后的日期对象
     */
    private static Object parseDateValue(String value, Field field) {
        try {
            // 检查是否有Excel注解
            Excel excelAnnotation = field.getAnnotation(Excel.class);
            if (excelAnnotation != null) {
                return parseDateValue(value, excelAnnotation);
            }
            
            // 默认日期格式解析
            java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse(value);
            return date;
            
        } catch (Exception e) {
            System.out.println("日期解析失败: " + field.getName() + " [" + value + "], 错误: " + e.getMessage());
            return null;
        }
    }
    
    /**
     * 应用值映射转换
     * 
     * @param value 原始值
     * @param mappingConfig 映射配置
     * @return 转换后的值
     */
    private static String applyValueMapping(String value, String mappingConfig) {
        if (value == null || value.trim().isEmpty() || mappingConfig == null) {
            return value;
        }
        
        try {
            // 解析映射配置：格式为 "源值1:目标值1,源值2:目标值2"
            String[] mappings = mappingConfig.split(",");
            for (String mapping : mappings) {
                String[] parts = mapping.split(":");
                if (parts.length == 2) {
                    String sourceValue = parts[0].trim();
                    String targetValue = parts[1].trim();
                    if (sourceValue.equals(value)) {
                        System.out.println("值映射: [" + value + "] -> [" + targetValue + "]");
                        return targetValue;
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("值映射解析失败: " + mappingConfig + ", 错误: " + e.getMessage());
        }
        
        return value; // 未找到映射，返回原值
    }
    
    /**
     * 格式化数字值，处理Excel数字格式问题
     * 
     * @param value 字符串值
     * @param cellValue 原始单元格值
     * @return 格式化后的值
     */
    private static String formatNumericValue(String value, Object cellValue) {
        if (value == null || value.trim().isEmpty()) {
            return value;
        }
        
        try {
            // 如果原始值是数字类型，且字符串值以.0结尾，则去掉.0
            if (cellValue instanceof Number && value.endsWith(".0")) {
                String formattedValue = value.substring(0, value.length() - 2);
                System.out.println("数字格式处理: " + value + " -> " + formattedValue);
                return formattedValue;
            }
            
            // 处理其他数字格式问题
            if (value.matches("\\d+\\.0+$")) {
                String formattedValue = value.replaceAll("\\.0+$", "");
                System.out.println("数字格式处理: " + value + " -> " + formattedValue);
                return formattedValue;
            }
            
        } catch (Exception e) {
            System.out.println("数字格式处理失败: " + value + ", 错误: " + e.getMessage());
        }
        
        return value;
    }

}